Webframeworkk/ASP.NET Core/Laufzeitumgebung

1. Einführung: Was sind Umgebungen?

In ASP.NET Core sind Umgebungen benannte Konfigurationen, die es Ihnen ermöglichen, Einstellungen, Konfigurationen und Middleware-Pipelines für spezifische Szenarien anzupassen. Dies hilft bei der Verwaltung von Unterschieden zwischen der Entwicklung, dem Testen und dem produktiven Einsatz.

Die gängigsten Umgebungen sind:

• Development (Entwicklung): Ihre lokale Umgebung, in der Sie die Anwendung erstellen und testen. Hier benötigen Sie oft detaillierte Fehlermeldungen.
• Staging (Vorproduktion): Eine Umgebung, die der Produktion sehr ähnlich ist und für letzte Tests und Validierungen genutzt wird.
• Production (Produktion): Die Live-Umgebung, mit der Ihre Endbenutzer interagieren. Sicherheit und Performance stehen hier im Vordergrund.

2. Festlegen der Umgebung

ASP.NET Core liest die aktuelle Umgebung beim Start aus der Umgebungsvariable ASPNETCORE_ENVIRONMENT. Der Wert dieser Variable bestimmt die aktive Umgebung.

Es gibt mehrere Wege, diese Variable zu setzen:

A. launchSettings.json (Für Visual Studio / Lokale Entwicklung)

Diese Datei befindet sich im Ordner Properties Ihres Projekts. Sie wird hauptsächlich von Visual Studio verwendet.

{
  "profiles": {
    "IhrProjektName": {
      "commandName": "Project",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

B. Über das Terminal / die Kommandozeile

Sie können die Umgebung direkt beim Starten der Anwendung angeben:

dotnet run --environment Staging

Oder indem Sie die Umgebungsvariable in Ihrer Konsole setzen:

PowerShell:

$env:ASPNETCORE_ENVIRONMENT = "Development"
dotnet run

Windows Eingabeaufforderung (CMD):

set ASPNETCORE_ENVIRONMENT=Production
dotnet run

macOS / Linux (Bash):

export ASPNETCORE_ENVIRONMENT=Staging
dotnet run

C. Systemweite Umgebungsvariablen

Für dauerhafte Einstellungen auf einem Server oder Entwicklungsrechner können Sie ASPNETCORE_ENVIRONMENT auch als systemweite Umgebungsvariable konfigurieren.

3. Verwendung von Umgebungen im Code (Program.cs)

Sie können auf die aktuelle Umgebung zugreifen und bedingte Logik verwenden, um Ihre Anwendung zu konfigurieren.

Zugriff auf die Umgebung

var builder = WebApplication.CreateBuilder(args);
var environment = builder.Environment; 
// environment.EnvironmentName enthält den Namen (z.B. "Development")

Bedingte Middleware-Konfiguration

Ein häufiges Beispiel ist die Fehlerseite. In der Entwicklung möchten Sie detaillierte Fehler sehen, in der Produktion jedoch eine generische Fehlerseite.

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage(); // Detaillierte Fehlerseite für Entwickler
}
else
{
    app.UseExceptionHandler("/Error"); // Generische Fehlerseite für Benutzer
    app.UseHsts();
}

Umgebungsspezifische Konfigurationsdateien

ASP.NET Core lädt automatisch Konfigurationsdateien basierend auf der Umgebung. Dies ermöglicht es Ihnen, unterschiedliche Einstellungen (z.B. Datenbank-Connection-Strings) zu verwalten.

1. 1. appsettings.json: Globale Einstellungen.
2. 2. appsettings.Development.json: Überschreibt Einstellungen für die Entwicklung.
3. 3. appsettings.Production.json: Überschreibt Einstellungen für die Produktion.

4. Die IWebHostEnvironment Schnittstelle

Wenn Sie in Ihren Controllern oder anderen Klassen Zugriff auf die Umgebungsinformationen benötigen, können Sie die IWebHostEnvironment-Schnittstelle per Dependency Injection (DI) einbinden.

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Hosting; // Wichtig für IWebHostEnvironment

public class HomeController : Controller
{
    private readonly IWebHostEnvironment _webHostEnvironment;

    public HomeController(IWebHostEnvironment webHostEnvironment)
    {
        _webHostEnvironment = webHostEnvironment;
    }

    public IActionResult Index()
    {
        // Zugriff auf Eigenschaften
        var envName = _webHostEnvironment.EnvironmentName;
        var webRoot = _webHostEnvironment.WebRootPath;
        var contentRoot = _webHostEnvironment.ContentRootPath;

        // Prüfung der Umgebung
        if (_webHostEnvironment.IsDevelopment())
        {
            ViewBag.Message = "Wir sind im Entwicklungsmodus!";
        }

        return View();
    }
}

Wichtige Methoden von IWebHostEnvironment:

• IsDevelopment(): Gibt true zurück, wenn die Umgebung "Development" ist.
• IsStaging(): Gibt true zurück, wenn die Umgebung "Staging" ist.
• IsProduction(): Gibt true zurück, wenn die Umgebung "Production" ist.
• IsEnvironment("MeinCustomName"): Prüft auf benutzerdefinierte Umgebungsnamen.

5. Developer Exception Page

Die Developer Exception Page ist ein Werkzeug, das bei Fehlern während der Entwicklung detaillierte Informationen anzeigt:

• Stack Trace (Fehlerverlauf)
• Query-String Parameter
• Cookies
• HTTP-Header

Wichtig: Diese Seite sollte niemals in der Produktion aktiviert werden, da sie sensible Informationen preisgeben könnte. Aktivieren Sie sie nur im Development-Modus (siehe Abschnitt 3).

6. Der Tag Helper

In Razor Views können Sie den <environment> Tag Helper verwenden, um HTML-Inhalte basierend auf der aktuellen Umgebung ein- oder auszublenden. Dies ist besonders nützlich für das Laden von Skripten oder Stylesheets.

Syntax

Include (Einschließen): Zeigt den Inhalt nur in den angegebenen Umgebungen an.

<environment include="Development">
    <!-- Unkomprimiertes CSS für einfacheres Debugging -->
    <link rel="stylesheet" href="~/css/site.css" />
    <p>Debug-Modus aktiv</p>
</environment>

Exclude (Ausschließen): Zeigt den Inhalt in allen Umgebungen an, AUSSER den angegebenen.

<environment exclude="Development">
    <!-- Minifiziertes CSS für bessere Performance in Produktion -->
    <link rel="stylesheet" href="~/css/site.min.css" />
</environment>

7. Best Practices

• Sicherheit: Nutzen Sie umgebungsspezifische Konfigurationsdateien, um sensible Daten (wie Produktions-Datenbankpasswörter) nicht in der Entwicklungsumgebung zu speichern.
• Keine Debug-Infos in Produktion: Stellen Sie sicher, dass Tools wie die DeveloperExceptionPage in der Produktion deaktiviert sind.
• Logging: Konfigurieren Sie Logging so, dass in der Entwicklung mehr Details (Verbose) und in der Produktion nur wichtige Fehler (Error/Warning) protokolliert werden.
• Feature Flags: Nutzen Sie Umgebungsvariablen, um bestimmte Features in verschiedenen Umgebungen an- oder abzuschalten.

Zusammenfassung: Umgebungen in ASP.NET Core bieten eine flexible Möglichkeit, Ihre Anwendung zu steuern. Durch die Nutzung von ASPNETCORE_ENVIRONMENT, IWebHostEnvironment und dem <environment> Tag Helper können Sie sicherstellen, dass Ihre App in jeder Phase des Lebenszyklus (Entwicklung, Test, Produktion) optimal und sicher läuft.